package dianxin.q2;

import java.util.Scanner;
import java.util.Scanner;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 读取输入字符串 S
        String inputString = scanner.next();

        // 读取两个整数 l 和 r
        long leftIndex = scanner.nextLong();
        long rightIndex = scanner.nextLong();

        // 调用函数获取子串并输出
        System.out.println(extractSubstring(inputString, leftIndex, rightIndex));

        scanner.close();
    }

    /**
     * 从构造的字符串 T 中提取从第 l 个字符到第 r 个字符之间的子串。
     *
     * @param s 原始字符串
     * @param l 起始位置（1-based）
     * @param r 结束位置（1-based）
     * @return 子串
     */
    public static String extractSubstring(String s, long l, long r) {
        int length = s.length();
        long[] prefixSum = new long[length + 1];
        prefixSum[0] = 0;

        // 预计算累积和 prefixSum[k] = k*length - (k-1)*k/2
        for (int k = 1; k <= length; k++) {
            prefixSum[k] = prefixSum[k - 1] + (long)(length - (k - 1));
        }

        StringBuilder result = new StringBuilder();
        long currentPosition = l;
        while (currentPosition <= r) {
            // 找到当前 position 所属的拼接步骤 step
            int step = binarySearchStep(currentPosition, prefixSum, length);

            // 计算步骤 step 的起始位置
            long stepStart = prefixSum[step - 1] + 1;

            // 计算在步骤 step 中的位置偏移量
            long offset = currentPosition - stepStart;

            // 计算在步骤 step 中可以提取的字符数
            long remainingInStep = prefixSum[step] - currentPosition + 1;
            long toTake = Math.min(r - currentPosition + 1, remainingInStep);

            // 计算在字符串 s 中的起始和结束索引
            int startIndex = (int)(step - 1 + offset);
            int endIndex = (int)(startIndex + toTake);

            // 提取子串并追加到结果中
            result.append(s, startIndex, endIndex);

            // 更新当前处理的位置
            currentPosition += toTake;
        }

        return result.toString();
    }

    /**
     * 使用二分查找找到最小的 step，使得 prefixSum[step] >= targetPosition。
     *
     * @param targetPosition 目标位置
     * @param prefixSum 累积和数组
     * @param length 字符串长度
     * @return 步骤 step
     */
    private static int binarySearchStep(long targetPosition, long[] prefixSum, int length) {
        int low = 1;
        int high = length;
        int result = length;
        while (low <= high) {
            int mid = low + (high - low) / 2;
            if (prefixSum[mid] >= targetPosition) {
                result = mid;
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return result;
    }
}